home *** CD-ROM | disk | FTP | other *** search
/ Nebula 2 / Nebula Two.iso / SourceCode / Palettes / PAStringList / PAStringList.m < prev    next >
Text File  |  1995-06-12  |  14KB  |  369 lines
  1. #import "PAStringList.h"
  2.  
  3. /******************************************************************************
  4. PAStringList
  5.  
  6.     The PAStringList (a subclass of Storage) is a convenient way to deal with lists of character strings. It contains methods for adding strings, inserting strings, sorting strings and searching for strings.
  7.         
  8.     The PAStringList can also add strings from a delimited string (such as the ones passed to an app by the workspace). The delimiters can be supplied or assumed to be white space.
  9.     
  10.     Finally, the PAStringList implements a browser delegate method so that it can easily display itself if set to be a browser delegate.
  11.  
  12.     To use this object inside of InterfaceBuilder, simply drag its icon from the palettes window into the suitcases window. Then drag in a browser and set its delegate to be the stringlist. Type in some entries into PAStringList's inspector and test interface. The browser fills up!
  13.  
  14.     Copyright 1992, Jeff Martin (jmartin@next.com) (415) 780-3833.
  15. ******************************************************************************/
  16.     
  17. @implementation PAStringList : Storage
  18.  
  19. - init
  20. { 
  21.     // Customize Storage to be 'char *' only
  22.     [super initCount:0 elementSize:4 description:"*"];
  23.  
  24.     // StringList is assumed to be sorted by default and when emptied
  25.     //    Adding a string without sorted flag causes 'isSorted' to be set to NO
  26.     isSorted = YES;
  27.     return self; 
  28. }
  29.  
  30. /******************************************************************************
  31.     addString:, addStringIfAbsent: addStringNoCopy: addStringIfAbsentNoCopy:
  32.     addString:at:, addStringIfAbsent:at:, addStringIfAbsent:at:
  33.     addStringSorted:, addStringIfAbsentSorted:, addStringIfAbsentNoCopySorted:
  34.  
  35.     These methods are convenience methods that simply call the master addString method and provide shorter names for cleaner use assuming the defaults of ifAbsent=NO, noCopy=NO, sorted=NO and at=count. Returns the result of the main addString method (self).
  36. ******************************************************************************/
  37. - addString:(const char *)string { return 
  38.     [self addString:string ifAbsent:NO noCopy:NO sorted:NO at:[self count]];  }
  39. - addStringIfAbsent:(const char *)string { return 
  40.     [self addString:string ifAbsent:YES noCopy:NO sorted:NO at:[self count]]; }
  41. - addStringNoCopy:(const char *)string { return 
  42.     [self addString:string ifAbsent:NO noCopy:YES sorted:NO at:[self count]]; }
  43. - addStringIfAbsentNoCopy:(const char *)string { return
  44.     [self addString:string ifAbsent:YES noCopy:YES sorted:NO at:[self count]];}
  45.  
  46. - addString:(const char *)string at:(int)at;
  47. { return [self addString:string ifAbsent:NO noCopy:NO sorted:NO at:at]; }
  48. - addStringIfAbsent:(const char *)string at:(int)at;
  49. { return [self addString:string ifAbsent:YES noCopy:NO sorted:NO at:at]; }
  50. - addStringNoCopy:(const char *)string at:(int)at;
  51. { return [self addString:string ifAbsent:NO noCopy:YES sorted:NO at:at]; }
  52. - addStringIfAbsentNoCopy:(const char *)string at:(int)at;
  53. { return [self addString:string ifAbsent:YES noCopy:YES sorted:NO at:at]; }
  54.  
  55. - addStringSorted:(const char *)string;
  56. { return [self addString:string ifAbsent:NO noCopy:NO sorted:YES at:0]; }
  57. - addStringIfAbsentSorted:(const char *)string;
  58. { return [self addString:string ifAbsent:YES noCopy:NO sorted:YES at:0]; }
  59. - addStringNoCopySorted:(const char *)string;
  60. { return [self addString:string ifAbsent:NO noCopy:YES sorted:YES at:0]; }
  61. - addStringIfAbsentNoCopySorted:(const char *)string;
  62. { return [self addString:string ifAbsent:YES noCopy:YES sorted:YES at:0]; }
  63.  
  64. /******************************************************************************
  65.     addString:ifAbsent:noCopy:sorted:at:
  66.  
  67.     This method provides a flexible method for adding strings to the list. The ifAbsent flag specifies whether a string should be added if it already exists. The noCopy flag specifies whether the given string should be used (or copied). The sorted flag specifies whether the string should be added alphabetically. The at value specifies where the string should be inserted at if it is not added alphabetically. Returns self.
  68. ******************************************************************************/
  69. - addString:(const char *)string ifAbsent:(BOOL)ifAbsent noCopy:(BOOL)noCopy sorted:(BOOL)sorted at:(int)at
  70. {
  71.     BOOL stringExists;
  72.     int index = (ifAbsent || sorted)? 
  73.         [self indexOfString:string exists:&stringExists] : 0;
  74.  
  75.     // If we add only if absent and string is in list return self
  76.     if(ifAbsent && stringExists) return self;
  77.  
  78.     // If not noCopy (in other words, if copy) make copy
  79.     if(!noCopy) string = NXCopyStringBufferFromZone(string, [self zone]);
  80.  
  81.     // If sorted, get index else add at 'at'; otherwise set isSorted flag to NO
  82.     if(sorted) at = index; else isSorted = NO;
  83.     
  84.     // Add the string and return
  85.     [self insertElement:(char **)&string at:at];
  86.     return self;
  87. }
  88.  
  89. /******************************************************************************
  90.     addStrings, addPAStringList
  91.  
  92.     These methods allow for lists of strings to be added either from a char ** or from a PAStringList object. Returns self.
  93. ******************************************************************************/
  94. - addStrings:(const char *const*)strings { return 
  95.     [self addStrings:strings ifAbsent:NO noCopy:NO sorted:NO at:[self count]];}
  96. - addStrings:(const char *const*)strings ifAbsent:(BOOL)ifAbsent noCopy:(BOOL)noCopy sorted:(BOOL)sorted at:(int)at
  97. {
  98.     char **temp = (char **)strings;
  99.     
  100.     // Add each string individually, incrementing 'at' to preserve their order
  101.     while(*temp) {
  102.         [self addString:*temp ifAbsent:ifAbsent noCopy:noCopy 
  103.             sorted:sorted at:at];
  104.         at++; temp++;
  105.     }
  106.     
  107.     // If 'noCopy' then we own the memory 'strings' and should free it
  108.     if(noCopy) free((char *)strings);
  109.     
  110.     return self;
  111. }
  112.  
  113. - addPAStringList:stringListObject 
  114. { return [self addStrings:[stringListObject strings]]; }
  115. - addPAStringList:stringListObject ifAbsent:(BOOL)ifAbsent noCopy:(BOOL)noCopy sorted:(BOOL)sorted at:(int)at
  116. { return [self addStrings:[stringListObject strings] ifAbsent:ifAbsent 
  117.         noCopy:noCopy sorted:sorted at:at]; }
  118.  
  119. /******************************************************************************
  120.     addDelimitedStrings:delimiters:
  121.     addDelimitedStrings:delimiters:ifAbsent:sorted:at:
  122.  
  123.     This method takes a delimited string (like the ones passed from the workspace) and searches for the given delimiters (NULL for general whitespace). It adds each string that it finds between the delimiters using the addString method. Returns self.
  124. ******************************************************************************/
  125. - addDelimitedStrings:(const char *)string delimiters:(const char *)dels
  126. { return [self addDelimitedStrings:string delimiters:dels ifAbsent:NO  sorted:NO at:[self count]]; }
  127. - addDelimitedStrings:(const char *)string delimiters:(const char *)dels ifAbsent:(BOOL)ifAbsent sorted:(BOOL)sorted at:(int)at
  128. {
  129.     static char defaultDels[] = {' ', '\t', '\n', '\r', '\0'};
  130.     int delCount, i;
  131.     char *currChar, *currString, *stringEnd;
  132.  
  133.     // Check to see if we were handed a bogus string
  134.     if(!string || !strlen(string)) return self;
  135.  
  136.     // Check for default delimiter and get number of delimiters
  137.     if(!dels) dels = defaultDels;
  138.     delCount = strlen(dels) + 1;
  139.     
  140.     // Make copy of the string (going to use string as scratch)
  141.     string = NXCopyStringBuffer(string);
  142.     currChar = currString = (char *)string; 
  143.     stringEnd = (char *)((int)string+strlen(string));
  144.     
  145.     // Look at each character until we pass null terminator(stringEnd)
  146.     while(currChar <= stringEnd) {
  147.         
  148.         // Check the character against the delimiters
  149.         for(i=0; i<delCount; i++)
  150.  
  151.             // If current character matches a delimiter add current string
  152.             if(*currChar==dels[i]) {
  153.             
  154.                 // Set delimiter to NULL('\0')
  155.                 *currChar = '\0'; 
  156.                 
  157.                 // Only add if there is something to add. Increment at.
  158.                 if(strlen(currString))
  159.                     [self addString:currString ifAbsent:ifAbsent noCopy:NO 
  160.                         sorted:sorted at:at++];
  161.  
  162.                 // set currString to start of next string(just past curr del)
  163.                 currString = currChar + 1;
  164.                 break;
  165.             }
  166.         currChar++;
  167.     }
  168.     
  169.     free((char *)string);
  170.     return self;
  171. }
  172.  
  173.  
  174. /******************************************************************************
  175.     (const char *const*)strings
  176.     (const char *)stringAt:(int)at
  177.  
  178.     The strings methods returns all of the strings as an array of char pointers. This array is NOT null terminated.
  179.     The stringAt: method returns the string at a particular index.
  180. ******************************************************************************/
  181. - (const char *const*)strings     { return (const char *const*)dataPtr; }
  182. - (const char *)stringAt:(int)at { return *(char **)[self elementAt:at]; }
  183.  
  184.  
  185. /******************************************************************************
  186.     (BOOL)stringExists
  187.     (unsigned int)indexOfString
  188.     (unsigned int)indexOfString exists:(BOOL *)exists
  189.  
  190.     stringExists returns whether or not the string is already in the list. indexOfString returns either the strings current index or the index that it should be alphabetically(returning [self count] if not sorted).
  191.     indexOfString:stringExists: is a composite method that returns both values in about the same amount of time that it takes to compute one.
  192. ******************************************************************************/
  193. - (BOOL)stringExists:(const char *)string
  194. { BOOL exists; [self indexOfString:string exists:&exists]; return exists; }
  195.  
  196. - (unsigned)indexOfString:(const char *)string
  197. { return [self indexOfString:string exists:NULL]; }
  198.  
  199. - (unsigned)indexOfString:(const char *)string exists:(BOOL *)exists
  200. {
  201.     int index;
  202.     
  203.     // Assume the string won't be found
  204.     if(exists) *exists = NO;
  205.  
  206.     // If list is empty or no string or zero strlen, return end of list
  207.     if(![self count] || !string || !strlen(string)) return [self count];
  208.     
  209.     // If not sorted do sequential search
  210.     if(!isSorted) {
  211.         int i=0;
  212.         for(i=0; i<[self count]; i++) 
  213.             if([self stringAt:i] && (!strcasecmp(string, [self stringAt:i]))) 
  214.                 { if(exists) *exists = YES; break; }
  215.  
  216.         index = i;
  217.     }
  218.     
  219.     // Otherwise if it is sorted do a binary search
  220.     else {
  221.         int l = 0;                        // lower index
  222.         int u = [self count] - 1;        // upper index
  223.         int m = 0;                        // middle index
  224.         int guess = 0;                    // compare val.
  225.         
  226.         while(l <= u) {
  227.             m = (l+u)/2;
  228.             guess = strcasecmp([self stringAt:m], string);
  229.             
  230.             // If guess is too high, adjust the upper value
  231.             if(guess>0) u = m-1;
  232.             
  233.             // If guess is too low, adjust the lower value
  234.             else if(guess<0) l = m+1;
  235.             
  236.             // If guess is equal to string, set 'exists' flag and break
  237.             else { if(exists) *exists = YES; break; }
  238.         }
  239.  
  240.         // If last guess was right or too high index is m; if too low then m+1;
  241.         if(guess>=0) index = m; else index = m+1;
  242.     }
  243.  
  244.     return index;
  245. }
  246.  
  247.  
  248. /******************************************************************************
  249.     removeString:(const char *)string
  250.     removeStrings:(const char *const*)strings
  251.     removeStringAt:(int)at
  252.  
  253.     These methods allow for the removal of strings by value or index. Returns self.
  254. ******************************************************************************/
  255. - removeString:(const char *)string
  256. {
  257.     BOOL exists;
  258.     int index = [self indexOfString:string exists:&exists];
  259.     if(exists) [self removeStringAt:index];
  260.     return self;
  261. }
  262. - removeStrings:(const char *const*)strings
  263. {
  264.     int i;
  265.     for(i=0; i<[self count]; i++) [self removeString:strings[i]];
  266.     return self;
  267. }
  268. - (char *)removeStringAt:(int)at
  269. {
  270.     char *string = (char *)[self stringAt:at];
  271.     [self removeElementAt:at];
  272.     if(![self count]) isSorted = YES;
  273.     return string;
  274. }
  275.  
  276. /******************************************************************************
  277.     (BOOL)isSorted
  278.     sortStrings:sender
  279.     
  280.     isSorted returns whether or not the list is currently considered to be sorted. Lists are set to be sorted by default and when empty. isSorted is set to NO when a string is added without the 'sorted' flag.
  281.     sortStrings: sorts the stringList (ignoring case) and sets the sorted flag. Returns self.
  282. ******************************************************************************/
  283. - (BOOL)isSorted    { return isSorted; }
  284.  
  285. // Wrap around strcasecmp to accept 'char **' and NULL strings(NULLs to back)
  286. static int strPtrCaseCmp(const void *s1, const void *s2)
  287. {
  288.     if(*(char **)s1==*(char **)s2) return 0;
  289.     else if(!*(char **)s1) return 1; else if(!*(char **)s2) return -1;
  290.     else return strcasecmp(*((char **)s1),*((char **)s2));
  291. }
  292.  
  293. - sortStrings:sender
  294. {
  295.     qsort(dataPtr, [self count], sizeof(char *), strPtrCaseCmp); 
  296.     isSorted = YES;
  297.     return self;
  298. }
  299.  
  300. /******************************************************************************
  301.     Write and read the PAStringList for archiving.
  302. ******************************************************************************/
  303. - write:(NXTypedStream *)stream
  304. {    
  305.     [super write:stream];
  306.     NXWriteType(stream, "c", &isSorted);
  307.     return self;
  308. }
  309.  
  310. - read:(NXTypedStream *)stream
  311. {
  312.     [super read:stream];
  313.     NXReadType(stream, "c", &isSorted);
  314.     return self;
  315. }
  316.  
  317. /******************************************************************************
  318.     empty, freeStrings, free
  319.     
  320.     These methods empty the list, free the strings and free the list, respectively.
  321. ******************************************************************************/
  322. - empty { isSorted = YES; return [super empty]; }
  323.  
  324. - freeStrings
  325. {
  326.     while([self count]) free([self removeStringAt:0]); 
  327.     return self;
  328. }
  329.  
  330. - free
  331. { 
  332.     return [super free];
  333. }
  334.  
  335. /******************************************************************************
  336.     (int)browser:sender fillMatrix:matrix inColumn:(int)column
  337.     
  338.     This method is provided as a delegate method for browser to quickly display string list.
  339. ******************************************************************************/
  340. - (int)browser:sender fillMatrix:matrix inColumn:(int)column
  341. {
  342.     int   i;
  343.     id   cellList, theCell;
  344.   
  345.     // Set matrix to have the right number of cells.
  346.     [matrix renewRows:[self count] cols:1];
  347.  
  348.     // Get list of cells from the matrix.
  349.     cellList = [matrix cellList];
  350.  
  351.     // For each cell set its value, set whether it is a leaf or not and 
  352.     //   mark it loaded.
  353.     for(i=0;i<[cellList count];i++) {
  354.         theCell = [cellList objectAt:i];
  355.         [theCell setStringValue:[self stringAt:i]];
  356.         [theCell setLeaf:YES];
  357.         [theCell setLoaded:YES];
  358.     }
  359.  
  360.     // Return the number of rows.
  361.     return [self count];
  362. }
  363.  
  364. // Interface Builder support
  365. - (const char *)getInspectorClassName { return "PAStringListInspector"; }
  366.  
  367. @end
  368.  
  369. // Fixed indexOf: bug. Thanks Stefanie Herzer!